/**
 * 计算两点之间的距离
 * @param {Object} point1 - 第一个点 {x, y}
 * @param {Object} point2 - 第二个点 {x, y}
 * @returns {number} 距离值
 */
export function calculateDistance(point1, point2) {
  if (!point1 || !point2 || 
      typeof point1.x !== 'number' || typeof point1.y !== 'number' ||
      typeof point2.x !== 'number' || typeof point2.y !== 'number') {
    return 0;
  }
  
  const dx = point2.x - point1.x;
  const dy = point2.y - point1.y;
  return Math.sqrt(dx * dx + dy * dy);
}
 
/**
 * 计算绘制速度
 * @param {number} distance - 距离
 * @param {number} time - 时间差(毫秒)
 * @returns {number} 速度值
 */
export function calculateSpeed(distance, time) {
  if (typeof distance !== 'number' || typeof time !== 'number' || time <= 0) {
    return 0;
  }
  
  return distance / time;
}
 
/**
 * 根据速度计算线宽
 * @param {number} speed - 绘制速度
 * @param {number} minWidth - 最小线宽
 * @param {number} maxWidth - 最大线宽
 * @returns {number} 计算后的线宽
 */
export function calculateLineWidth(speed, minWidth = 2, maxWidth = 6) {
  if (typeof speed !== 'number' || speed < 0) {
    return minWidth;
  }
  
  // 速度越快，线条越细
  const speedFactor = Math.min(speed / 10, 1); // 将速度标准化到0-1范围
  const width = maxWidth - (maxWidth - minWidth) * speedFactor;
  
  return clamp(width, minWidth, maxWidth);
}
 
/**
 * 获取弧度数据
 * @param {number} x1 - 起始点x坐标
 * @param {number} y1 - 起始点y坐标
 * @param {number} x2 - 结束点x坐标
 * @param {number} y2 - 结束点y坐标
 * @returns {Object} 弧度相关数据 {val, pos}
 */
export function getRadianData(x1, y1, x2, y2) {
  if (typeof x1 !== 'number' || typeof y1 !== 'number' ||
      typeof x2 !== 'number' || typeof y2 !== 'number') {
    return { val: 0, pos: 1 };
  }
  
  const dis_x = x2 - x1;
  const dis_y = y2 - y1;
  
  if (dis_x === 0) {
    return { val: 0, pos: -1 };
  }
  if (dis_y === 0) {
    return { val: 0, pos: 1 };
  }
  
  const val = Math.abs(Math.atan(dis_y / dis_x));
  if ((x2 > x1 && y2 < y1) || (x2 < x1 && y2 > y1)) {
    return { val: val, pos: 1 };
  }
  return { val: val, pos: -1 };
}
 
/**
 * 根据弧度获取点坐标
 * @param {Object} center - 中心点
 * @param {number} radius - 半径
 * @param {number} angle - 角度(弧度)
 * @returns {Object} 点坐标 {x, y}
 */
export function getRadianPoint(center, radius, angle) {
  if (!center || typeof center.x !== 'number' || typeof center.y !== 'number' ||
      typeof radius !== 'number' || typeof angle !== 'number') {
    return { x: 0, y: 0 };
  }
  
  return {
    x: center.x + radius * Math.cos(angle),
    y: center.y + radius * Math.sin(angle)
  };
}
 
/**
 * 根据弧度数据获取垂直于线段的两个点
 * @param {Object} radianData - 弧度数据对象，包含val和pos属性
 * @param {number} x - 中心点x坐标
 * @param {number} y - 中心点y坐标
 * @param {number} halfLineWidth - 线宽的一半
 * @returns {Array} 包含两个点的数组 [{x, y}, {x, y}]
 */
export function getRadianPoints(radianData, x, y, halfLineWidth) {
  if (!radianData || typeof radianData.val !== 'number' || typeof radianData.pos !== 'number' ||
      typeof x !== 'number' || typeof y !== 'number' ||
      typeof halfLineWidth !== 'number') {
    return [{ x: 0, y: 0 }, { x: 0, y: 0 }];
  }
  
  if (radianData.val === 0) {
    if (radianData.pos === 1) {
      return [
        { x: x, y: y + halfLineWidth },
        { x: x, y: y - halfLineWidth }
      ];
    }
    return [
      { y: y, x: x + halfLineWidth },
      { y: y, x: x - halfLineWidth }
    ];
  }
  
  const dis_x = Math.sin(radianData.val) * halfLineWidth;
  const dis_y = Math.cos(radianData.val) * halfLineWidth;
  
  if (radianData.pos === 1) {
    return [
      { x: x + dis_x, y: y + dis_y },
      { x: x - dis_x, y: y - dis_y }
    ];
  }
  return [
    { x: x + dis_x, y: y - dis_y },
    { x: x - dis_x, y: y + dis_y }
  ];
}
 
/**
 * 数值精度处理
 * @param {number} value - 需要处理的数值
 * @param {number} precision - 精度位数
 * @returns {number} 处理后的数值
 */
export function toFixed(value, precision = 1) {
  if (typeof value !== 'number' || typeof precision !== 'number') {
    return 0;
  }
  
  return parseFloat(value.toFixed(Math.max(0, precision)));
}
 
/**
 * 限制数值在指定范围内
 * @param {number} value - 输入值
 * @param {number} min - 最小值
 * @param {number} max - 最大值
 * @returns {number} 限制后的值
 */
export function clamp(value, min, max) {
  if (typeof value !== 'number' || typeof min !== 'number' || typeof max !== 'number') {
    return value || 0;
  }
  
  return Math.min(Math.max(value, min), max);
}
 
/**
 * 线性插值
 * @param {number} start - 起始值
 * @param {number} end - 结束值
 * @param {number} factor - 插值因子(0-1)
 * @returns {number} 插值结果
 */
export function lerp(start, end, factor) {
  if (typeof start !== 'number' || typeof end !== 'number' || typeof factor !== 'number') {
    return start || 0;
  }
  
  return start + (end - start) * clamp(factor, 0, 1);
}
 
/**
 * 角度转弧度
 * @param {number} degrees - 角度值
 * @returns {number} 弧度值
 */
export function degreesToRadians(degrees) {
  if (typeof degrees !== 'number') {
    return 0;
  }
  
  return degrees * (Math.PI / 180);
}
 
/**
 * 弧度转角度
 * @param {number} radians - 弧度值
 * @returns {number} 角度值
 */
export function radiansToDegrees(radians) {
  if (typeof radians !== 'number') {
    return 0;
  }
  
  return radians * (180 / Math.PI);
}
 
/**
 * 默认导出所有数学工具函数
 */
export default {
  calculateDistance,
  calculateSpeed,
  calculateLineWidth,
  getRadianData,
  getRadianPoints,
  toFixed,
  clamp,
  lerp
};